In assembly language programming, the function prologue is a few lines of code at the beginning of a function, which prepare the stack and registers for use within the function. Similarly, the function epilogue appears at the end of the function, and restores the stack and registers to the state they were in before the function was called.
The prologue and epilogue are not a part of the assembly language itself; they represent a convention used by assembly language programmers, and compilers of many higher-level languages. They are fairly rigid, having the same form in each function.
Contents |
A function prologue typically does the following actions if the architecture has a base pointer (also known as frame pointer) and a stack pointer (the following actions may not be applicable to those architectures that are missing a base pointer or stack pointer) :
Several possible prologues can be written, resulting in slightly different stack configuration. These differences are acceptable, as long as the programmer or compiler uses the stack in the correct way inside the function.
For example, these three steps may be accomplished in 32-bit x86 assembly language by the following instructions (using AT&T syntax):
Where n is the size of the local variables, in bytes, and l means long, which occupies 4 bytes. The above sequence is typical of the output produced by the GCC compiler.
The x86 uses a slightly different prologue; it can be called with the enter instruction:
More complex prologues can be obtained using different values (other than 0) for the second operand of the enter instruction. These prologues push several base/frame pointers to allow for nested functions, as required by languages such as Pascal. Modern versions of these languages however don't use these instructions because they limit the procedure-nesting depth in some cases.
Function epilogue reverses the actions of the function prologue and returns control to the calling function. It typically does the following actions (this procedure may differ from one architecture to another):
The given epilogue will reverse the effects of either of the above prologues (either the full one, or the one which uses enter).
For example, these three steps may be accomplished in 32-bit x86 assembly language by the following instructions (using AT&T syntax):
Like the prologue, the x86 processor contains a built-in instruction which performs part of the epilogue. The following code is equivalent to the above code:
The leave instruction performs the mov and pop instructions, as outlined above.
A function may contain multiple epilogues. Every function exit point must either jump to a common epilogue at the end, or contain its own epilogue. Therefore, programmers or compilers often use the combination of leave and ret to exit the function at any point. (For example, a C compiler would substitute a return statement with a leave/ret sequence).